// 投诉建议页面逻辑
const { getCurrentRole } = require('../../../utils/auth')
const { submitComplaint, getComplaints, getComplaintStats, updateComplaint, cancelComplaint, getComplaintReplies } = require('../../../api/complaints')

Page({
  data: {
    // 统计数据
    stats: {
      total: 0,
      pending: 0,
      processing: 0,
      completed: 0,
      cancelled: 0
    },
    // 全局加载状态
    globalLoading: false,
    globalLoadingText: '村务信息加载中...',
    
    // 当前筛选状态
    currentFilter: 'all',
    
    // 投诉建议列表
    complaints: [],
    
    // 筛选后的投诉建议列表
    filteredComplaints: [],
    
    // 投诉类型选项
    complaintTypes: [
      { value: 'service', label: '服务态度', icon: '🏛️' },
      { value: 'efficiency', label: '办事效率', icon: '⏰' },
      { value: 'facility', label: '设施环境', icon: '🏢' },
      { value: 'other', label: '其他建议', icon: '💬' }
    ],
    
    // 表单数据
    formData: {
      type: '',
      title: '',
      content: '',
      contact: '',
      urgent: false
    },
    
    // 选中的投诉类型
    selectedType: '',
    
    // 是否显示弹窗
    showModal: false,
    
    // 是否正在编辑
    editingComplaint: null,
    
    // 回复相关
    showReplyModal: false,
    currentReply: null,
    replyData: null,
    loadingReplies: false,
    
    // 表单验证错误状态
    showTypeError: false,
    showTitleError: false,
    showContentError: false,
    showContactError: false,
    
    // 错误提示信息
    titleErrorMsg: '',
    contentErrorMsg: '',
    contactErrorMsg: ''
  },

  // 显示全局加载
  showGlobalLoading(text = '村务信息加载中...') {
    const app = getApp()
    app.showGlobalLoading({
      loadingText: text
    })
  },

  // 隐藏全局加载
  hideGlobalLoading() {
    const app = getApp()
    app.hideGlobalLoading()
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalLoadingText: data.globalLoadingText || this.data.globalLoadingText
    })
  },

  async onLoad(options) {
    // 显示页面加载效果
    this.showGlobalLoading('村务信息加载中...')
    // 检查登录状态
    this.checkLoginStatus()
    
    // 加载用户数据
    await this.loadComplaintsData()
  },

  async onShow() {
    // 检查登录状态
    this.checkLoginStatus()
    
    // 重新加载数据（确保数据是最新的）
    await this.loadComplaintsData()
  },

  // 检查登录状态
  checkLoginStatus() {
    try {
      const role = getCurrentRole()
      if (!role) {
        wx.redirectTo({ url: '/pages/auth/login/index' })
        return
      }
    } catch (e) {
      console.error('获取角色失败:', e)
      wx.redirectTo({ url: '/pages/auth/login/index' })
    }
  },

  // 加载投诉建议数据
  async loadComplaintsData() {
    try {
      // 显示加载状态
      // 获取统计数据
      const statsResult = await getComplaintStats()
      if (statsResult.success) {
        this.setData({ stats: statsResult.data })
      } else {
        console.warn('获取统计数据失败:', statsResult.message)
      }
      
      // 获取投诉建议列表
      const complaintsResult = await getComplaints({ status: 'all' })
      if (complaintsResult.success) {
        // 转换数据格式以适配前端显示
        const complaints = complaintsResult.data.complaints.map(item => ({
          id: item.id,
          type: this.getTypeLabel(item.type),
          typeIcon: this.getTypeIcon(item.type),
          title: item.title,
          content: item.content,
          status: item.status,
          statusText: this.getStatusText(item.status),
          statusClass: item.status,
          createTime: this.formatDate(new Date(item.submitTime)),
          contact: item.contact || '',
          urgent: item.urgent || false
        }))
        
        this.setData({ complaints })
        
        // 重新筛选数据
        this.filterComplaints()
        
        // 隐藏加载状态
        // 隐藏全局加载
        this.hideGlobalLoading()
        
        // 显示成功提示
        wx.showToast({ 
          title: '数据加载成功', 
          icon: 'success',
          duration: 1000
        })
      } else {
        // 隐藏全局加载
        this.hideGlobalLoading()
        wx.showToast({ 
          title: complaintsResult.message || '获取数据失败', 
          icon: 'none',
          duration: 2000
        })
        // 清空投诉列表，避免显示假数据
        this.setData({ complaints: [] })
      }
    } catch (error) {
      // 隐藏全局加载
      this.hideGlobalLoading()
      console.error('加载投诉数据失败:', error)
      
      // 清空投诉列表，避免显示假数据
      this.setData({ complaints: [] })
      
      // 根据错误类型显示不同的提示
      if (error.type === 'network') {
        wx.showToast({ 
          title: '网络连接失败，请检查网络设置', 
          icon: 'none',
          duration: 2000
        })
      } else if (error.status === 401) {
        wx.showToast({ 
          title: '登录已过期，请重新登录', 
          icon: 'none',
          duration: 2000
        })
        // 跳转到登录页面
        setTimeout(() => {
          wx.redirectTo({ url: '/pages/auth/login/index' })
        }, 2000)
      } else {
        wx.showToast({ 
          title: error.message || '数据加载失败', 
          icon: 'none',
          duration: 2000
        })
      }
    }
  },

  // 获取类型标签
  getTypeLabel(type) {
    const typeMap = {
      'service': '服务态度',
      'efficiency': '办事效率', 
      'facility': '设施环境',
      'other': '其他建议'
    }
    return typeMap[type] || '其他建议'
  },

  // 获取类型图标
  getTypeIcon(type) {
    const iconMap = {
      'service': '🏛️',
      'efficiency': '⏰',
      'facility': '🏢', 
      'other': '💬'
    }
    return iconMap[type] || '💬'
  },

  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'pending': '待处理',
      'processing': '处理中',
      'completed': '已处理',
      'cancelled': '已撤销'
    }
    return statusMap[status] || '未知状态'
  },

  // 筛选投诉建议
  filterComplaints() {
    const { complaints, currentFilter } = this.data
    let filtered = complaints
    
    if (currentFilter !== 'all') {
      filtered = complaints.filter(item => item.status === currentFilter)
    }
    // 在"全部"筛选中，显示所有数据（包括已撤销的）
    
    this.setData({ filteredComplaints: filtered })
  },

  // 筛选状态改变
  onFilterChange(e) {
    const filter = e.currentTarget.dataset.filter
    this.setData({ currentFilter: filter })
    this.filterComplaints()
  },

  // 快速投诉
  onQuickComplaint(e) {
    const type = e.currentTarget.dataset.type
    const typeMap = {
      'service': 'service',
      'efficiency': 'efficiency', 
      'facility': 'facility',
      'other': 'other'
    }
    
    this.setData({
      selectedType: typeMap[type],
      formData: {
        type: typeMap[type],
        title: '',
        content: '',
        contact: '',
        urgent: false
      },
      editingComplaint: null,
      showModal: true
    })
  },

  // 查看投诉详情
  onViewComplaint(e) {
    const id = e.currentTarget.dataset.id
    const complaint = this.data.complaints.find(item => item.id === id)
    
    if (complaint) {
      wx.showModal({
        title: complaint.title,
        content: `类型：${complaint.type}\n内容：${complaint.content}\n状态：${complaint.statusText}\n时间：${complaint.createTime}`,
        showCancel: false,
        confirmText: '知道了'
      })
    }
  },

  // 编辑投诉
  onEditComplaint(e) {
    const id = e.currentTarget.dataset.id
    const complaint = this.data.complaints.find(item => item.id === id)
    
    if (complaint) {
      // 检查是否可以编辑（只有待处理状态的投诉可以编辑）
      if (complaint.status !== 'pending') {
        wx.showModal({
          title: '提示',
          content: '只有待处理状态的投诉建议可以编辑',
          showCancel: false,
          confirmText: '知道了'
        })
        return
      }
      
      // 根据投诉类型找到对应的value值
      const typeMap = {
        '服务态度': 'service',
        '办事效率': 'efficiency',
        '设施环境': 'facility',
        '其他建议': 'other'
      }
      
      const typeValue = typeMap[complaint.type] || 'other'
      
      this.setData({
        editingComplaint: complaint,
        selectedType: typeValue,
        formData: {
          type: typeValue,
          title: complaint.title,
          content: complaint.content,
          contact: complaint.contact,
          urgent: complaint.urgent || false
        },
        showModal: true
      })
      
      // 显示编辑提示
      wx.showToast({
        title: '进入编辑模式',
        icon: 'none',
        duration: 1500
      })
    } else {
      wx.showToast({ title: '未找到投诉建议', icon: 'none' })
    }
  },

  // 撤销申请
  onCancelComplaint(e) {
    const id = e.currentTarget.dataset.id
    const complaint = this.data.complaints.find(item => item.id === id)
    
    if (complaint) {
      // 检查是否可以撤销（只有待处理和处理中状态的投诉可以撤销）
      if (complaint.status === 'completed') {
        wx.showModal({
          title: '提示',
          content: '已处理的投诉建议无法撤销',
          showCancel: false,
          confirmText: '知道了'
        })
        return
      }
      
      // 显示撤销确认弹窗
      wx.showModal({
        title: '确认撤销',
        content: `确定要撤销投诉"${complaint.title}"吗？撤销后将无法恢复。`,
        confirmText: '确认撤销',
        confirmColor: '#dc2626',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            this.cancelComplaint(id)
          }
        }
      })
    } else {
      wx.showToast({ title: '未找到投诉建议', icon: 'none' })
    }
  },

  // 执行撤销操作
  async cancelComplaint(id) {
    try {
      const result = await cancelComplaint(id)
      
      if (result.success) {
        wx.showToast({
          title: '撤销成功',
          icon: 'success',
          duration: 2000
        })
        
        // 重新从服务器加载数据，确保数据一致性
        await this.loadComplaintsData()
      } else {
        wx.showToast({ 
          title: result.message || '撤销失败', 
          icon: 'none' 
        })
      }
    } catch (error) {
      console.error('撤销投诉失败:', error)
      wx.showToast({ 
        title: '网络错误，请稍后重试', 
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 查看回复
  async onViewReply(e) {
    const id = e.currentTarget.dataset.id
    const complaint = this.data.complaints.find(item => item.id === id)
    
    if (complaint) {
      // 根据投诉状态显示不同的内容
      if (complaint.status === 'pending') {
        // 待处理状态 - 显示等待提示，但也可以尝试获取是否有临时回复
        await this.loadComplaintReplies(id, complaint, 'pending')
      } else if (complaint.status === 'processing') {
        // 处理中状态 - 获取并显示处理进度和可能的回复
        await this.loadComplaintReplies(id, complaint, 'processing')
      } else if (complaint.status === 'completed') {
        // 已处理状态 - 获取并显示回复内容
        await this.loadComplaintReplies(id, complaint, 'completed')
      } else if (complaint.status === 'cancelled') {
        // 已撤销状态 - 显示撤销信息，但也可以查看历史回复
        await this.loadComplaintReplies(id, complaint, 'cancelled')
      }
    } else {
      wx.showToast({ title: '未找到投诉建议', icon: 'none' })
    }
  },

  // 加载投诉建议的回复记录
  async loadComplaintReplies(complaintId, complaint, status) {
    try {
      this.setData({ loadingReplies: true })
      
      const result = await getComplaintReplies(complaintId)
      
      if (result.success) {
        const replyData = result.data
        
        // 根据状态设置不同的提示信息
        let statusMessage = ''
        let showReplies = true
        
        switch (status) {
          case 'pending':
            statusMessage = '您的投诉建议已提交，正在等待工作人员处理。'
            break
          case 'processing':
            statusMessage = '您的投诉建议正在处理中，工作人员已开始调查核实。'
            break
          case 'completed':
            statusMessage = '您的投诉建议已处理完成。'
            break
          case 'cancelled':
            statusMessage = '该投诉建议已被撤销。'
            break
        }
        
        this.setData({
          currentReply: {
            complaint: complaint,
            replyData: replyData,
            statusMessage: statusMessage,
            currentStatus: status,
            showReplies: showReplies
          },
          showReplyModal: true
        })
      } else {
        // 如果获取回复失败，根据状态显示不同的提示
        let message = ''
        switch (status) {
          case 'pending':
            message = '您的投诉建议已提交，正在等待工作人员处理。我们会尽快安排专人处理您的反馈。'
            break
          case 'processing':
            message = '您的投诉建议正在处理中，工作人员已开始调查核实。处理完成后会及时回复您。'
            break
          case 'completed':
            message = result.message || '获取回复失败，请稍后重试。'
            break
          case 'cancelled':
            message = '该投诉建议已被撤销，无法查看回复。'
            break
        }
        
        wx.showModal({
          title: '投诉状态',
          content: message,
          showCancel: false,
          confirmText: '知道了'
        })
      }
    } catch (error) {
      console.error('获取回复记录失败:', error)
      
      // 根据状态显示不同的错误提示
      let message = ''
      switch (status) {
        case 'pending':
          message = '您的投诉建议已提交，正在等待工作人员处理。'
          break
        case 'processing':
          message = '您的投诉建议正在处理中，请耐心等待。'
          break
        case 'completed':
          message = '网络错误，请稍后重试。'
          break
        case 'cancelled':
          message = '该投诉建议已被撤销。'
          break
      }
      
      wx.showModal({
        title: '投诉状态',
        content: message,
        showCancel: false,
        confirmText: '知道了'
      })
    } finally {
      this.setData({ loadingReplies: false })
    }
  },

  // 获取回复数据
  getReplyData(complaintId) {
    const replyMap = {
      'c1': {
        id: 'r1',
        content: '感谢您的反馈！我们已收到您关于工作人员服务态度的投诉。经调查核实，我们已对相关工作人员进行了批评教育，并要求其改进服务态度。同时，我们也会加强员工培训，提升整体服务质量。',
        replyTime: '2024-10-07 09:30',
        replyBy: '张主任',
        status: '已回复'
      },
      'c2': {
        id: 'r2', 
        content: '您提出的办事流程复杂问题很有建设性。我们正在研究简化低保申请流程的方案，计划在下个月推出"一站式"服务，减少群众跑腿次数。具体进展我们会及时通知。',
        replyTime: '2024-10-06 14:20',
        replyBy: '李科长',
        status: '已回复'
      },
      'c3': {
        id: 'r3',
        content: '关于办事大厅座椅不足的问题，我们已安排采购部门增加座椅数量，预计本周内完成安装。同时，我们也会优化大厅布局，为办事群众提供更舒适的等待环境。',
        replyTime: '2024-10-04 10:15',
        replyBy: '王主任',
        status: '已回复'
      },
      'c4': {
        id: 'r4',
        content: '在线预约功能建议非常好！我们正在开发微信小程序预约系统，预计年底前上线。届时群众可以通过手机提前预约办事时间，避免现场排队。',
        replyTime: '2024-10-02 16:45',
        replyBy: '技术部',
        status: '已回复'
      }
    }
    
    return replyMap[complaintId] || {
      id: 'default',
      content: '感谢您的反馈，我们已收到您的投诉建议，正在积极处理中。如有疑问，请联系工作人员。',
      replyTime: '2024-10-08 10:00',
      replyBy: '工作人员',
      status: '处理中'
    }
  },

  // 关闭回复弹窗
  onCloseReplyModal() {
    this.setData({
      showReplyModal: false,
      currentReply: null,
      replyData: null
    })
  },

  // 新增投诉
  onAddComplaint() {
    this.setData({
      selectedType: '',
      formData: {
        type: '',
        title: '',
        content: '',
        contact: '',
        urgent: false
      },
      editingComplaint: null,
      showModal: true
    })
  },

  // 关闭弹窗
  onCloseModal() {
    this.setData({ 
      showModal: false,
      formData: {
        type: '',
        title: '',
        content: '',
        contact: '',
        urgent: false
      },
      selectedType: '',
      editingComplaint: null,
      // 清除错误状态
      showTypeError: false,
      showTitleError: false,
      showContentError: false,
      showContactError: false,
      titleErrorMsg: '',
      contentErrorMsg: '',
      contactErrorMsg: ''
    })
  },

  // 选择投诉类型
  onSelectType(e) {
    const type = e.currentTarget.dataset.type
    this.setData({ 
      selectedType: type,
      showTypeError: false
    })
  },

  // 输入标题
  onTitleInput(e) {
    const value = e.detail.value
    this.setData({
      'formData.title': value,
      showTitleError: false
    })
    
    // 实时验证标题
    this.validateTitle(value)
  },

  // 输入内容
  onContentInput(e) {
    const value = e.detail.value
    this.setData({
      'formData.content': value,
      showContentError: false
    })
    
    // 实时验证内容
    this.validateContent(value)
  },

  // 输入联系方式
  onContactInput(e) {
    const value = e.detail.value
    this.setData({
      'formData.contact': value,
      showContactError: false
    })
    
    // 延迟验证联系方式，避免频繁触发
    clearTimeout(this.contactValidateTimer)
    this.contactValidateTimer = setTimeout(() => {
      this.validateContact(value)
    }, 500)
  },

  // 切换紧急状态
  onToggleUrgent() {
    this.setData({
      'formData.urgent': !this.data.formData.urgent
    })
  },

  // 验证标题
  validateTitle(value) {
    if (!value || !value.trim()) {
      this.setData({
        showTitleError: true,
        titleErrorMsg: '请输入标题'
      })
      return false
    }
    
    if (value.trim().length < 5) {
      this.setData({
        showTitleError: true,
        titleErrorMsg: '标题至少需要5个字符'
      })
      return false
    }
    
    if (value.trim().length > 50) {
      this.setData({
        showTitleError: true,
        titleErrorMsg: '标题不能超过50个字符'
      })
      return false
    }
    
    return true
  },

  // 验证内容
  validateContent(value) {
    if (!value || !value.trim()) {
      this.setData({
        showContentError: true,
        contentErrorMsg: '请输入详细内容'
      })
      return false
    }
    
    if (value.trim().length < 10) {
      this.setData({
        showContentError: true,
        contentErrorMsg: '详细内容至少需要10个字符'
      })
      return false
    }
    
    return true
  },

  // 验证联系方式
  validateContact(value) {
    if (value && value.trim()) {
      if (!/^1[3-9]\d{9}$/.test(value.trim())) {
        this.setData({
          showContactError: true,
          contactErrorMsg: '请输入正确的手机号码'
        })
        return false
      }
    }
    
    return true
  },

  // 验证投诉类型
  validateType() {
    if (!this.data.selectedType) {
      this.setData({
        showTypeError: true
      })
      return false
    }
    return true
  },

  // 提交投诉
  async onSubmitComplaint() {
    const { formData, selectedType, editingComplaint } = this.data
    
    // 验证表单
    const isTypeValid = this.validateType()
    const isTitleValid = this.validateTitle(formData.title)
    const isContentValid = this.validateContent(formData.content)
    const isContactValid = this.validateContact(formData.contact)
    
    if (!isTypeValid || !isTitleValid || !isContentValid || !isContactValid) {
      // 显示第一个错误提示
      if (!isTypeValid) {
        wx.showToast({ title: '请选择投诉类型', icon: 'none' })
      } else if (!isTitleValid) {
        wx.showToast({ title: this.data.titleErrorMsg, icon: 'none' })
      } else if (!isContentValid) {
        wx.showToast({ title: this.data.contentErrorMsg, icon: 'none' })
      } else if (!isContactValid) {
        wx.showToast({ title: this.data.contactErrorMsg, icon: 'none' })
      }
      return
    }
    
    // 显示加载状态
    try {
      if (editingComplaint) {
        // 编辑模式 - 调用更新接口
        const updateData = {
          type: selectedType,
          title: formData.title.trim(),
          content: formData.content.trim(),
          contact: formData.contact.trim(),
          urgent: formData.urgent
        }
        
        const result = await updateComplaint(editingComplaint.id, updateData)
        
        if (result.success) {
          wx.showModal({
            title: '修改成功',
            content: '您的投诉建议已成功修改，我们会及时处理您的反馈。',
            showCancel: false,
            confirmText: '知道了'
          })
          
          // 重新从服务器加载数据，确保数据一致性
          await this.loadComplaintsData()
        } else {
          wx.showToast({ title: result.message || '修改失败', icon: 'none' })
          return
        }
      } else {
        // 新增模式 - 调用提交接口
        const submitData = {
          type: selectedType,
          title: formData.title.trim(),
          content: formData.content.trim(),
          contact: formData.contact.trim(),
          urgent: formData.urgent
        }
        
        const result = await submitComplaint(submitData)
        
        if (result.success) {
          wx.showToast({ 
            title: '提交成功', 
            icon: 'success',
            duration: 2000
          })
          
          // 重新从服务器加载数据，确保数据一致性
          await this.loadComplaintsData()
        } else {
          wx.showToast({ title: result.message || '提交失败', icon: 'none' })
          return
        }
      }
      
      // 重置表单数据
      this.setData({
        formData: {
          type: '',
          title: '',
          content: '',
          contact: '',
          urgent: false
        },
        selectedType: '',
        editingComplaint: null,
        // 清除错误状态
        showTypeError: false,
        showTitleError: false,
        showContentError: false,
        showContactError: false,
        titleErrorMsg: '',
        contentErrorMsg: '',
        contactErrorMsg: ''
      })
      
      this.filterComplaints()
      this.setData({ showModal: false })
      
    } catch (error) {
      console.error('提交投诉失败:', error)
      wx.showToast({ 
        title: '网络错误，请稍后重试', 
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 格式化日期
  formatDate(date) {
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, '0')
    const day = String(date.getDate()).padStart(2, '0')
    const hours = String(date.getHours()).padStart(2, '0')
    const minutes = String(date.getMinutes()).padStart(2, '0')
    return `${year}-${month}-${day} ${hours}:${minutes}`
  },

  // 下拉刷新
  async onPullDownRefresh() {
    try {
      // 重新加载数据
      await this.loadComplaintsData()
      
      // 停止下拉刷新
      wx.stopPullDownRefresh()
      
      // 显示刷新成功提示
      wx.showToast({ 
        title: '刷新成功', 
        icon: 'success',
        duration: 1000
      })
    } catch (error) {
      // 停止下拉刷新
      wx.stopPullDownRefresh()
      
      // 显示刷新失败提示
      wx.showToast({ 
        title: '刷新失败', 
        icon: 'none',
        duration: 1500
      })
    }
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 阻止事件冒泡
  }
})